// 引入销售订单相关模型
// sales_orders: 销售订单模型
// customers: 客户模型
// products: 产品模型
const { sales_orders, customers, products } = require('../models/init-models')(require('../db').sequelize, require('sequelize').DataTypes)
// 引入数据库连接实例
const { sequelize } = require('../db');
// 引入Sequelize，用于操作符
const Sequelize = require('sequelize');
// 引入工具函数
// formatPagination: 格式化分页参数
// buildLikeQuery: 构建模糊查询条件
// generatePaginationInfo: 生成分页信息
const { formatPagination, buildLikeQuery, generatePaginationInfo } = require('../utils')
// 导入订单状态配置
const orderStatusConfig = require('../orderStatusConfig');

/**
 * 获取销售订单列表（支持分页和筛选）
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * 
 * 功能说明:
 * 1. 支持分页查询
 * 2. 支持按订单编号、客户名称、订单状态、订单日期范围、婴儿名称、产品名称筛选
 * 3. 返回订单列表和分页信息
 * 
 * API设计原则：
 * 1. 使用HTTP GET方法，符合RESTful API规范
 * 2. 支持多种查询参数，提高API灵活性
 * 3. 返回结构化数据，便于前端处理
 */
const getSalesOrderList = async (req, res) => {
  try {
    // 从请求查询参数中获取分页和筛选信息
    // page: 页码，默认为1
    const page = parseInt(req.query.page) || 1;
    // pageSize: 每页显示条数，默认为10
    const pageSize = parseInt(req.query.pageSize) || 10;
    // orderId: 订单ID筛选条件
    const orderId = req.query.orderId;
    // orderNumber: 订单编号筛选条件
    const orderNumber = req.query.orderNumber;
    // customerName: 客户名称筛选条件
    const customerName = req.query.customerName;
    // status: 订单状态筛选条件
    const status = req.query.status;
    // startDate: 订单开始日期筛选条件
    const startDate = req.query.startDate;
    // endDate: 订单结束日期筛选条件
    const endDate = req.query.endDate;
    // babyName: 婴儿名称筛选条件
    const babyName = req.query.babyName;
    // productName: 产品名称筛选条件
    const productName = req.query.productName;
    // isPaid: 收款状态筛选条件
    const isPaid = req.query.isPaid;  // 添加收款状态参数

    // 构建查询条件
    // whereConditions: Sequelize查询条件对象
    const whereConditions = {};
    
    // 如果提供了订单ID，添加到查询条件
    if (orderId) {
      whereConditions.order_id = orderId;
    }
    
    // 如果提供了订单编号，添加到查询条件
    if (orderNumber) {
      // 使用Sequelize操作符构建模糊查询条件
      whereConditions.order_number = {
        [Sequelize.Op.like]: `%${orderNumber}%`
      };
    }
    
    // 如果提供了日期范围，添加到查询条件
    if (startDate && endDate) {
      // 使用Sequelize操作符构建日期范围查询条件
      whereConditions.order_date = {
        [Sequelize.Op.between]: [startDate, endDate]
      };
    } else if (startDate) {
      // 使用Sequelize操作符构建大于等于查询条件
      whereConditions.order_date = {
        [Sequelize.Op.gte]: startDate
      };
    } else if (endDate) {
      // 使用Sequelize操作符构建小于等于查询条件
      whereConditions.order_date = {
        [Sequelize.Op.lte]: endDate
      };
    }
    
    // 如果提供了婴儿名称，添加到查询条件
    if (babyName) {
      // 使用Sequelize操作符构建模糊查询条件
      whereConditions.baby_name = {
        [Sequelize.Op.like]: `%${babyName}%`
      };
    }
    
    // 如果提供了订单状态，添加到查询条件
    if (status) {
      whereConditions.status = status;
    }
    
    // 如果提供了收款状态，添加到查询条件
    if (isPaid !== undefined && isPaid !== null) {
      whereConditions.payment_status = isPaid;
    }

    // 构建关联查询条件
    // includeConditions: Sequelize关联查询条件数组
    const includeConditions = [
      {
        model: customers,                 // 关联的模型
        as: 'customer',                   // 关联别名
        attributes: ['customer_id', 'customer_name', 'contact_person', 'phone', 'address'], // 查询字段
        // 如果提供了客户名称，添加到关联查询条件
        where: customerName ? {
          customer_name: {
            [Sequelize.Op.like]: `%${customerName}%`
          }
        } : undefined,
        // 如果没有提供客户名称，不需要where条件
        required: !!customerName          // 是否为内连接
      },
      {
        model: products,                  // 关联的模型
        as: 'product',                    // 关联别名
        attributes: ['product_id', 'product_name'], // 查询字段
        // 如果提供了产品名称，添加到关联查询条件
        where: productName ? {
          product_name: {
            [Sequelize.Op.like]: `%${productName}%`
          }
        } : undefined,
        // 如果没有提供产品名称，不需要where条件
        required: !!productName           // 是否为内连接
      }
    ];

    // 执行分页查询
    // findAndCountAll: Sequelize方法，同时查询数据和总条数
    const { count, rows } = await sales_orders.findAndCountAll({
      where: whereConditions,           // 查询条件
      include: includeConditions,       // 关联查询条件
      // 分页参数
      limit: pageSize,                  // 每页条数
      offset: (page - 1) * pageSize,    // 偏移量
      // 按创建时间降序排列
      order: [['created_at', 'DESC']]   // 排序条件
    });

    // 转换状态代码为标签
    // ordersWithLabels: 带有状态标签的订单数据数组
    const ordersWithLabels = rows.map(order => {
      const orderData = order.toJSON(); // 将Sequelize实例转换为普通对象
      // 通过订单状态配置获取状态标签文本
      orderData.status_label = orderStatusConfig.getStatusLabel(orderData.status);
      return orderData;
    });

    // 构建分页信息对象
    // paginationInfo: 分页信息对象
    const paginationInfo = {
      totalCount: count,                // 总记录数
      currentPage: page,                // 当前页码
      pageSize: pageSize,               // 每页条数
      totalPages: Math.ceil(count / pageSize) // 总页数
    };

    // 返回成功响应
    // res.success: 统一响应处理中间件提供的成功响应方法
    res.success({
      orders: ordersWithLabels,         // 订单列表数据
      pagination: paginationInfo        // 分页信息
    }, '获取销售订单列表成功');
  } catch (error) {
    // 错误处理：记录错误日志并返回错误响应
    console.error('获取销售订单列表失败:', error);
    // res.error: 统一响应处理中间件提供的错误响应方法
    res.error('获取销售订单列表失败');
  }
};

/**
 * 通过ID获取单个销售订单详情
 * 返回数据包含客户信息和产品信息
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * 
 * 功能说明:
 * 1. 根据订单ID查询订单详情
 * 2. 关联查询客户信息和产品信息
 * 3. 转换状态代码为标签文本
 */
const getSalesOrderById = async (req, res) => {
    try {
        // 从请求参数中获取订单ID
        const orderId = req.params.id;
        
        // 根据ID查找订单，包含客户信息和产品信息
        const order = await sales_orders.findByPk(orderId, {
            include: [
                { 
                    model: customers, 
                    as: 'customer',
                    attributes: ['customer_id', 'customer_name', 'contact_person', 'phone', 'address']
                },
                {
                    model: products,
                    as: 'product',
                    attributes: ['product_id', 'product_name']
                }
            ]
        });

        // 如果订单不存在，返回404错误
        if (!order) {
            return res.error('销售订单不存在', 1, 404);
        }

        // 转换状态代码为标签
        const orderData = order.toJSON();
        orderData.status_label = orderStatusConfig.getStatusLabel(orderData.status);

        // 返回订单信息（包含客户信息和产品信息）
        res.success(orderData, '获取销售订单信息成功');
    } catch (error) {
        res.error('获取销售订单信息失败');
    }
};

/**
 * 生成订单编号
 * 格式为DD+日期(年份后两位)+6位随机数
 * @returns {string} 订单编号
 */
function generateOrderNumber() {
  const now = new Date();
  const year = String(now.getFullYear()).slice(-2); // 只取年份后两位
  const month = String(now.getMonth() + 1).padStart(2, '0');
  const day = String(now.getDate()).padStart(2, '0');
  const dateStr = `${year}${month}${day}`;
  
  // 生成6位随机数
  const randomNum = String(Math.floor(Math.random() * 1000000)).padStart(6, '0');
  
  return `DD${dateStr}${randomNum}`;
}

/**
 * 添加销售订单
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * 
 * 功能说明:
 * 1. 创建订单（包含产品信息）
 * 2. 返回完整的订单信息
 */
const addSalesOrder = async (req, res) => {
  try {
    // 生成订单编号并确保唯一性
    let orderNumber;
    let isUnique = false;
    let attempts = 0;
    const maxAttempts = 10; // 最大尝试次数，防止无限循环
    
    while (!isUnique && attempts < maxAttempts) {
      orderNumber = generateOrderNumber();
      // 检查数据库中是否已存在该订单编号
      const existingOrder = await sales_orders.findOne({
        where: {
          order_number: orderNumber
        }
      });
      
      if (!existingOrder) {
        isUnique = true;
      }
      
      attempts++;
    }
    
    // 如果尝试次数超过最大限制，返回错误
    if (!isUnique) {
      return res.error('无法生成唯一的订单编号，请稍后重试', 1, 500);
    }
    
    // 生成订单数据
    const orderData = {
      ...req.body,
      order_number: orderNumber
    };
    
    // 创建销售订单（包含产品信息）
    const order = await sales_orders.create(orderData);
    
    // 重新查询订单信息，包含客户信息和产品信息
    const orderWithDetails = await sales_orders.findByPk(order.order_id, {
      include: [
        { 
          model: customers, 
          as: 'customer',
          attributes: ['customer_id', 'customer_name', 'contact_person', 'phone', 'address']
        },
        {
          model: products,
          as: 'product',
          attributes: ['product_id', 'product_name']
        }
      ]
    });
    
    // 转换状态代码为标签
    const orderDataWithLabel = orderWithDetails.toJSON();
    orderDataWithLabel.status_label = orderStatusConfig.getStatusLabel(orderDataWithLabel.status);
    
    // 返回成功响应
    res.success(orderDataWithLabel, '添加销售订单成功');
  } catch (error) {
    // 根据错误类型返回不同的错误信息
    if (error.name === 'SequelizeValidationError') {
      res.error(`数据验证失败: ${error.message}`, 1, 400);
    } else if (error.name === 'SequelizeForeignKeyConstraintError') {
      res.error('外键约束错误: 请检查客户ID或产品ID是否有效', 1, 400);
    } else if (error.name === 'SequelizeUniqueConstraintError') {
      // 处理订单编号重复的情况，重新生成
      res.error('订单编号重复，请重试', 1, 400);
    } else {
      res.error('添加销售订单失败');
    }
  }
};

/**
 * 更新销售订单信息
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * 
 * 功能说明:
 * 1. 更新订单信息（包含产品信息）
 * 2. 返回更新后的完整订单信息
 */
const updateSalesOrder = async (req, res) => {
  try {
    // 从请求体中获取订单ID
    const orderId = req.body.order_id;
    
    // 先查找订单是否存在
    const existingOrder = await sales_orders.findByPk(orderId);
    if (!existingOrder) {
      // 如果订单不存在，返回404错误
      return res.error('销售订单不存在', 1, 404);
    }
    
    // 更新订单信息
    const [updatedCount] = await sales_orders.update(req.body, {
      where: {
        order_id: orderId
      }
    });

    // 重新获取更新后的订单信息，包含客户信息和产品信息
    const updatedOrder = await sales_orders.findByPk(orderId, {
      include: [
        { 
          model: customers, 
          as: 'customer',
          attributes: ['customer_id', 'customer_name', 'contact_person', 'phone', 'address']
        },
        {
          model: products,
          as: 'product',
          attributes: ['product_id', 'product_name']
        }
      ]
    });

    // 转换状态代码为标签
    const updatedOrderData = updatedOrder.toJSON();
    updatedOrderData.status_label = orderStatusConfig.getStatusLabel(updatedOrderData.status);

    // 返回成功响应
    res.success(updatedOrderData, '更新销售订单成功');
  } catch (error) {
    res.error('更新销售订单失败');
  }
};

/**
 * 删除销售订单
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * 
 * 功能说明:
 * 1. 删除指定订单
 */
const delSalesOrder = async (req, res) => {
    try {
        // 从请求参数中获取订单ID
        const orderId = req.params.id;
        
        // 删除销售订单
        const deletedCount = await sales_orders.destroy({
            where: {
                order_id: orderId
            }
        });
        
        // 如果没有删除任何记录，说明订单不存在
        if (deletedCount === 0) {
            return res.error('销售订单不存在', 1, 404);
        }
        
        // 返回成功响应
        res.success({ deletedCount }, '删除销售订单成功');
    } catch (error) {
        res.error('删除销售订单失败');
    }
};

/**
 * 获取首页统计数据
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
const getDashboardStats = async (req, res) => {
    try {
        // 获取各类统计数据
        const [ordersCount, customersCount, productsCount, totalAmount] = await Promise.all([
            sales_orders.count(),
            customers.count(),
            products.count(),
            sales_orders.sum('total_amount')
        ]);
        
        // 格式化统计数据
        const stats = {
            orders: ordersCount,
            customers: customersCount,
            products: productsCount,
            totalAmount: totalAmount ? parseFloat(totalAmount).toFixed(2) : '0.00'
        };
        
        // 返回成功响应
        res.success(stats, '获取首页统计数据成功');
    } catch (error) {
        res.error('获取首页统计数据失败');
    }
};

/**
 * 获取最新订单列表
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
const getRecentOrders = async (req, res) => {
    try {
        // 查询最新的5个订单
        const orders = await sales_orders.findAll({
            limit: 5,
            order: [['created_at', 'DESC']],
            include: [{
                model: customers,
                as: 'customer',
                attributes: ['customer_name']
            }],
            attributes: ['order_id', 'order_number', 'total_amount', 'created_at']
        });
        
        // 格式化订单数据
        const formattedOrders = orders.map(order => {
            const orderData = order.toJSON();
            return {
                id: orderData.order_id,
                orderNumber: orderData.order_number,
                customer: orderData.customer ? orderData.customer.customer_name : '未知客户',
                amount: orderData.total_amount ? `¥${parseFloat(orderData.total_amount).toFixed(2)}` : '¥0.00',
                created_at: orderData.created_at
            };
        });
        
        // 返回成功响应
        res.success(formattedOrders, '获取最新订单成功');
    } catch (error) {
        res.error('获取最新订单失败');
    }
};

// 导出所有处理函数
module.exports = { 
    getSalesOrderList,
    getSalesOrderById,
    addSalesOrder,
    updateSalesOrder,
    delSalesOrder,
    getDashboardStats,     // 新增：获取首页统计数据
    getRecentOrders       // 新增：获取最新订单列表
}